package com.juc.threadPoolExecutor.threadPoolExecutor1;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Run3_1 {
    //数量>corePoolSize 并且<=maximumPoolSize的情况
	//队列使用LinkedBlockingDeque类，也就是
	//线程数量>corePoolSize时将其余的任务放入队列中
	//同一时间最多只能有7个线程在运行
	//如果使用LinkedBlockingDeque类则maximumPoolSize参数作用将忽略
	
	/**
	 * BlockingDeque常用的实现类LinkedBlockingQueue和ArrayBlockingQueue
	 * 用LinkedBlockingQueue的好处在于没有大小限制，优点是队列容量非常大，所以
	 * 执行execute()不会抛出异常，而线程池中运行的线程数也永远不会超过corePoolSize
	 * 值，因为其他多余的线程被放入LinkedBlockingQueue队列中，keepAliveTime
	 * 参数也就没有意义了.
	 */
	public static void main(String[] args) throws InterruptedException {
		Runnable runnable = new Runnable() {
			
			@Override
			public void run() {
				try {
					System.out.println(Thread.currentThread().getName() + " run! " +System.currentTimeMillis());
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		};
		ThreadPoolExecutor executor = new ThreadPoolExecutor(7, 8, 5, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>());
		executor.execute(runnable);//1
		executor.execute(runnable);//2
		executor.execute(runnable);//3
		executor.execute(runnable);//4
		executor.execute(runnable);//5
		executor.execute(runnable);//6
		executor.execute(runnable);//7
		executor.execute(runnable);//8
		Thread.sleep(300);
		System.out.println("A: " +executor.getCorePoolSize());
		System.out.println("A: " +executor.getPoolSize());
		System.out.println("A: " +executor.getQueue().size());
		Thread.sleep(10000);
		System.out.println("B: " +executor.getCorePoolSize());
		System.out.println("B: " +executor.getPoolSize());
		System.out.println("B: " +executor.getQueue().size());
	}
}
